#pragma once
#ifndef _TIMER_H_
#define _TIMER_H_

#include <functional>
/** 日期和时间库 [9/27/2020 ZC] */
#include <chrono>
/** 线程支持库 [9/27/2020 ZC] */
#include <thread>
/** 原子操作库 [9/27/2020 ZC] */
#include <atomic>
#include <memory>
#include <mutex>
#include <condition_variable>

class Timer
{
public:
	Timer() : _expired(true), _try_to_expire(false)
	{}

	Timer(const Timer& timer)
	{
		_expired = timer._expired.load();
		_try_to_expire = timer._try_to_expire.load();
	}

	~Timer()
	{
		stop();
	}

	void start(int interval, std::function<void()> task)
	{
		// is started, do not start again
		if (_expired == false)
			return;

		// start async timer, launch thread and wait in that thread
		_expired = false;
		std::thread([this, interval, task]() {
			while (!_try_to_expire)
			{
				// sleep every interval and do the task again and again until times up
				std::this_thread::sleep_for(std::chrono::milliseconds(interval));
				task();
			}

			{
				// timer be stopped, update the condition variable expired and wake main thread
				std::lock_guard<std::mutex> locker(_mutex);
				_expired = true;
				_expired_cond.notify_one();
			}
		}).detach();
	}
/**
* std::thread::detach：从thread对象分离执行线程，允许执行独立的持续。
* 一旦该线程退出，则释放任何分配的资源，调用detach后，*this不再占有任何线程
*/
	void startOnce(int delay, std::function<void()> task)
	{
		std::thread([delay, task]() {
			std::this_thread::sleep_for(std::chrono::milliseconds(delay));
			task();
		}).detach();
	}

	void stop()
	{
		// do not stop again
		if (_expired)
			return;

		if (_try_to_expire)
			return;

		// wait until timer 
		_try_to_expire = true; // change this bool value to make timer while loop stop
		{
			std::unique_lock<std::mutex> locker(_mutex);
			_expired_cond.wait(locker, [this] {return _expired == true; });

			// reset the timer
			if (_expired == true)
				_try_to_expire = false;
		}
	}

private:
/**
* std::atomic_bool为std::atomic<bool>的别名
* 原子类型：每个std::atomic模板的实例化和全特化定义一个原子类型
* 原子对象：原子类型的实例化
* 原子对象作用：（若一个线程写入原子对象），（另一个线程读取）保证线程读取，有一个良好的行为定义【与数据竞争有关】
* 线程间同步：对原子对象的访问可以建立线程间同步
*/

/**
* 线程与数据竞争
* 知识前提：任何线程都能潜在地访问程序中的任何对象
* （拥有自动或线程局部存储期的对象仍可以被另一线程通过指针或引用访问）
* 知识前提：始终允许不同的执行线程同时访问（读和写）【不同】的内存位置
* 而没有干涉和同步的任何要求
* 表达式冲突：当某个表达式的求值写入某个内存位置，
* 而另一个求值读或修改同一内存位置，称这些表达式冲突
* 数据竞争：拥有两个冲突的求值程序就可能有数据竞争
* 数据竞争的后果：程序未定义
* 什么情况有用两个冲突求值程序不会数据竞争：
* 1.两个求值都在同一线程，或统一信号处理中执行
* 2.两个冲突的求值都是原子操作
* 3.一个冲突的求值发生早于另一个
*/
	std::atomic_bool _expired; // timer stopped status
	std::atomic<bool> _try_to_expire; // timer is in stop process
	std::mutex _mutex;
	std::condition_variable _expired_cond;
};

#endif // !_TIMER_H_